#ifndef _UTILES_H
#define _UTILES_H

ST_CHS LBAtoCHS(int32_t sectorBuscado)
{
	int 	temporal;
	ST_CHS 	stCHS;

	stCHS.cilindro = (int) sectorBuscado / (stPPD.iHead * stPPD.iSector);
	temporal = sectorBuscado % (stPPD.iCilindro * stPPD.iSector);
	stCHS.cabeza = (int) temporal / stPPD.iSector;
	stCHS.sector = (int) (sectorBuscado % stPPD.iSector) ;

	/*  cylinder = LBA / (heads_per_cylinder * sectors_per_track)
		temp = LBA % (heads_per_cylinder * sectors_per_track)
		head = temp / sectors_per_track
		sector = temp % sectors_per_track + 1
	*/
	return stCHS;
}

/*============================================================================
SeparaCadena()
============================================================================*/
void SeparaCadena(char *sParametro,char *sValor,char *cadena) {

   int		iConta1=0,iConta2=0;

   strcpy(sParametro,cadena);

   while(sParametro[iConta1]!='='){
         iConta1++;
	}

	sParametro[iConta1]='\0';
    iConta1++;
    while(cadena[iConta1]!='\n') {
        sValor[iConta2]=cadena[iConta1];
	    iConta1++;iConta2++;
	 }

    sValor[iConta2]='\0';
}

/*============================================================================
cargarConfiguracion()
Lee el archivo de configuracion y carga los datos a la estructura del PRAID
============================================================================*/

int cargarConfiguracion() {

	FILE		*pArch;
	char		sParam[100],sValor[100],Aux[100];

	memset(Aux,'\0',100);
	stPPD.szPathConsola=(char *)malloc(sizeof(char)*250);

	//TODO CAMBIAR EL PATH PARA LA PRUEBA FINAL O EN EL DE PRUEBAS, PONER: ../PPD/
	if ((pArch = fopen("PPDconfig.txt", "r"))==NULL) {
		return 0;
	}

	while (!feof(pArch)) {
		fgets(Aux,100,pArch);
		SeparaCadena(sParam,sValor,Aux);

		if(strcmp(sParam,"MODO")==0)
			strcpy(stPPD.modo,sValor);
		else if(strcmp(sParam,"IPREMOTO")==0)
			strcpy(stPPD.szIpRemoto,sValor);
		else if(strcmp(sParam,"PUERTOREMOTO")==0)
			stPPD.iPuertoRemoto = atoi(sValor);
		else if(strcmp(sParam,"ALGORITMO")==0)
			strcpy(stPPD.cAlgoritmo,sValor);
		else if(strcmp(sParam,"IPPPD")==0)
			strcpy(stPPD.szIpPPD,sValor);
		else if(strcmp(sParam,"PUERTOPPD")==0)
			stPPD.iPuertoPPD = atoi(sValor);
		else if(strcmp(sParam,"ID")==0)
			strcpy(stPPD.szIdPPD,sValor);
		else if(strcmp(sParam,"FLAG")==0)
			stPPD.iFlag = atoi(sValor);
		else if(strcmp(sParam,"C")==0)
			stPPD.iCilindro = atoi(sValor);
		else if(strcmp(sParam,"H")==0)
			stPPD.iHead = atoi(sValor);
		else if(strcmp(sParam,"S")==0)
			stPPD.iSector = atoi(sValor);
		else if(strcmp(sParam,"TLECTURA")==0)
			stPPD.iTiempoLectura = atoi(sValor);
		else if(strcmp(sParam,"TESCRITURA")==0)
			stPPD.iTiempoEscritura = atoi(sValor);
		else if(strcmp(sParam,"RPM")==0)
			stPPD.iRPM = atoi(sValor);
		else if(strcmp(sParam,"TSALTO")==0)
			stPPD.iTiempoSalto = atoi(sValor);
		else if(strcmp(sParam,"PATH")==0)
			strcpy(stPPD.szPath,sValor);
		else if(strcmp(sParam, "PATHCONSOLA")==0)
			sprintf(stPPD.szPathConsola, "%s", sValor);
			//strcpy(stPPD.szPathConsola, sValor);

		else if(strcmp(sParam, "CANTELEMENTOS")==0)
			stPPD.cantElementosNStepScan = atoi(sValor);
	}
	stPPD.sectorActual=0;
	fclose(pArch);

	return 1;
}

/*============================================================================
iniciarLog()
Abre el archivo log y escribe el encabezado. Recibe como parametros:
- *nombreLog: nombre del archivo log a crearse.
============================================================================*/
void iniciarLog( const char *nombreLog )
{
	FILE		*pArchLog;
	time_t		tiempo;
	struct tm	*ptm;

	if(stPPD.iFlag == 1)
	{
		time(&tiempo);
		ptm = localtime(&tiempo );

		pArchLog = fopen(nombreLog,"a");

		fprintf(pArchLog, "Fecha\t  NombreProceso\t[PIDproceso]  [ThreadID]:TipoLog Dato\n");
		fprintf(pArchLog, "************************************************************\n");

		fclose(pArchLog);
	}
}

/*============================================================================
log()
Abre el archivo log y escribe al final. Recibe como parametros:
- *nombreLog: nombre del archivo log.
- *name: puntero al nombre del proceso.
- *type: tipo de mensaje (ERROR, INFO, etc).
- *log: puntero a la cadena, que contiene el mensaje a escribir en el archivo.
============================================================================*/
void log( const char *nombreLog, const char *name, const char *type, const char *log)
{
	FILE		*pArchLog;
	time_t		tiempo;
	struct tm	*ptm;
	if(stPPD.iFlag == 1)
	{
		time(&tiempo);

		ptm = gmtime(&tiempo );

		pArchLog = fopen(nombreLog,"a");

		fprintf(pArchLog, "[%2d:%02d:%02d]  [%s]\t[%d]\t\t[%d]\t[%s]\t[%s]\n",ptm->tm_hour, ptm->tm_min, ptm->tm_sec, name, getpid(), pthread_self(), type, log);
/*%2d:%02d:%04d - ptm->tm_mday, ptm->tm_mon+1, ptm->tm_year+1900, */
		fclose(pArchLog);
	}
}

/*============================================================================
generarSocketEscucha()
Funcion que genera el socket por el que escuchara el proceso.
============================================================================*/
int generarSocketEscucha ()	{

	int					iSocket, iYes, iRta;
	int					iBacklog=25;
	struct sockaddr_in	stDireccion;

	if((iSocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		log( "ppdLog.txt", "PPD", "ERROR", "Al generar el socket de escucha");
		return -1;
	} else {

    if(setsockopt(iSocket, SOL_SOCKET, SO_REUSEADDR, &iYes, sizeof(int)) == -1) {
    	log( "ppdLog.txt", "PPD", "ERROR", "Al generar el socket de escucha");
    	return -1;
	}}

	if( stPPD.szIpPPD == NULL ){
		stDireccion.sin_addr.s_addr = inet_addr(stPPD.szIpPPD);
	  } else {
		stDireccion.sin_addr.s_addr = inet_addr(stPPD.szIpPPD);
	  }

	  stDireccion.sin_family = AF_INET;		 /* host byte order*/
	  stDireccion.sin_port = htons( stPPD.iPuertoPPD );	 /* short, network byte order*/
	  memset( &(stDireccion.sin_zero), '\0', 8 );	/* rellena con ceros el resto de la estructura*/

	/*Se establece el socket para escucha (struct sockaddr *) */
	if( bind(iSocket, (struct sockaddr *)&stDireccion, sizeof(struct sockaddr)) == -1 ) {
		log( "ppdLog.txt", "PPD", "ERROR", "Al generar el socket de escucha");
		return -1;
	  } else {

     if( listen( iSocket, iBacklog ) == -1 ) { /*Establezco el socket para esperar conexiones*/
    	 log( "ppdLog.txt", "PPD", "ERROR", "Al generar el socket de escucha");
		 return -1;
	 }  }

return iSocket;
}

int atiendeNuevaConexion( void ) {
	int 				iNuevoSock;
	ST_NIPC				stCabecera;
	struct sockaddr_in	stDirNuevaCnx;	/* Informacion de la direccion de una nueva conexion*/
	socklen_t			sin_size;

	sin_size = sizeof(struct sockaddr_in); /*Tamaño de la estructura sockaddr_in*/
	memset( &stDirNuevaCnx, '\0', sin_size ); /*Inicializo la estructura*/

	if( (iNuevoSock = accept( stPPD.iSocketEscucha, (struct sockaddr *) &stDirNuevaCnx, &sin_size )) == -1) {
		log( "ppdLog.txt", "PPD", "ERROR", "Al aceptar nueva conexion");
		perror("error acept");
		//printf("error en accept");
		return -1;
	}

	if( recv( iNuevoSock, (void *) &stCabecera, sizeof(ST_NIPC), MSG_WAITALL) < 0 ) {
		close( iNuevoSock );
		perror("error recv");
		log( "ppdLog.txt", "PFD", "ERROR","Al recibir Mensaje de nueva conexion");
		//return -4;
	}
	//printf("ucType: %u\n",stCabecera.ucType);
	//printf("Antes de enviar respuesta al handshake\n");
	if(stCabecera.ucType == HANDSHAKE) {
		//printf("Recibi pedido de handshake\n");
		stCabecera.ucType = PPD;
		stCabecera.lPayload = 0;

		if( send( iNuevoSock, &stCabecera, sizeof(ST_NIPC), MSG_NOSIGNAL ) < 0 ){
			close( iNuevoSock );
			log( "ppdLog.txt", "PPD", "ERROR","Al enviar respuesta Hand Shake");
			//return -3;
		}else
			log( "ppdLog.txt", "PPD", "INFO", "Se conectó con el PFS");
		/* EN CASO DE ERROR CARGAR stCabecera.ucType CON FAIL Y ENVIAR */
	}
	//printf("Despues de enviar respuesta al handshake\n");
/* VERIFICAR SI ES NECESARIO GUARDAR iNuevoSock YA QUE SIEMPRE SE TRATARA DEL PFS, ESTE SE PODRA CONECTAR MAS DE UNA VEZ*/
	return iNuevoSock;
}

int CreaSocketPraid(char * ip, char * puerto)
{
	int sockfd;
    struct sockaddr_in their_addr;
	int port;

	port=atoi(puerto);

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }

    their_addr.sin_family = AF_INET;
    their_addr.sin_port = htons(port);
    their_addr.sin_addr.s_addr = inet_addr(ip);
    memset(&(their_addr.sin_zero),'\0', 8);
	//printf("Prueba Enviar\n");
    if (connect(sockfd, (struct sockaddr *)&their_addr,sizeof(their_addr)) == -1) {
        perror("connect");
        exit(1);
    }

	return sockfd;
}

/*============================================================================
leerBootSector_mmap()
============================================================================*/
int leerSector( ST_NIPC *rtaSector, int32_t sector_leer )
{
	//char* sectorLeido=(char*)malloc(sizeof(ST_SECTOR));
	float tiempoLectura=0;
	//ST_SECTOR buffer;
	tiempoLectura=stPPD.iTiempoLectura;

	//printf("sector a leer: %d\n", sector_leer);
	//printf("desplazamiento %d\n",sector_leer * sizeof(ST_SECTOR));
	char* sectorObtenido = stPPD.ArchivoEnDisco + sector_leer * sizeof(ST_SECTOR);
			//dameSector(sector_leer);

	//printf("sector obtenido: %s\n", sectorObtenido);

	//memset(rtaSector->buffer, 0, sizeof(ST_SECTOR));
	//memset(sectorObtenido, 0, sizeof(ST_SECTOR));
	memcpy(rtaSector->buffer, sectorObtenido, sizeof(ST_SECTOR));
	//if (lseek(stPPD.ArchivoEnDisco, stPPD.sectorActual , sector_leer) > 0)
	//	memcpy(buffer, stPPD.ArchivoEnDisco, sizeof(ST_SECTOR));
	if (tiempoLectura>0)
		sleep(tiempoLectura);
	//free(sectorObtenido);
	//printf("Sector Actual: %d\n", stPPD.sectorActual);
	//printf("Sector Leer: %d\n", sector_leer);
//	if (stPPD.sectorActual < sector_leer)
//		stPPD.sectorActual = sector_leer + 1;
//	else
//		stPPD.sectorActual = sector_leer - 1;
//
//	if (stPPD.sectorActual < 0)
//		stPPD.sectorActual = 0;
//
//	if (stPPD.sectorActual > stPPD.sectoresTotales - 1)
//		stPPD.sectorActual = stPPD.sectorActual -1;
	posicionoCabezal(sector_leer);

	return 0;
}

/*============================================================================
EscribirBootSector_mmap()
============================================================================*/
int EscribirSector( ST_SECTOR buffer, int32_t sector_escribir )
{
	int valorRetorno=0;
	int32_t filesize;
	float tiempoEscritura=0;
	tiempoEscritura=stPPD.iTiempoEscritura;

	char* sectorObtenido=(char*)malloc(sizeof(ST_SECTOR));
	sectorObtenido = (char*)(stPPD.ArchivoEnDisco + sector_escribir * sizeof(ST_SECTOR));
			//dameSector(sector_escribir);

	memcpy(sectorObtenido, buffer, 512);
	if (stPPD.enSincro == 0)
	{
		if (stPPD.cantSectoresEscritos == 32000)
		{
			//filesize = tamanioDisco();
			valorRetorno=msync(stPPD.ArchivoEnDisco, stPPD.filesize, MS_SYNC);
			stPPD.cantSectoresEscritos = 1;
		}else
		{
			stPPD.cantSectoresEscritos ++;
		}
	}
//		else
//	{
//		//filesize = tamanioDisco();
//		valorRetorno=msync(stPPD.ArchivoEnDisco, stPPD.filesize, MS_SYNC);
//		//vprintf("En sincro\n");
//	}

	if (tiempoEscritura > 0)
		sleep(tiempoEscritura);
	//free(sectorObtenido);

	//stPPD.sectorActual = sector_escribir + 1;

//	if (stPPD.sectorActual < sector_escribir)
//		stPPD.sectorActual = sector_escribir + 1;
//	else
//		stPPD.sectorActual = sector_escribir - 1;
//
//	if (stPPD.sectorActual<0)
//			stPPD.sectorActual = 0;
//
//	if (stPPD.sectorActual > stPPD.sectoresTotales - 1)
//		stPPD.sectorActual = stPPD.sectorActual -1;

	posicionoCabezal(sector_escribir);
	if(valorRetorno==-1)
		perror("Error msync");
	return valorRetorno;
}

//char *dameSector(int32_t sector)
//{
//	return stPPD.ArchivoEnDisco + sector * 512;
//}

int32_t tamanioDisco()
{
	long  tamanio=0;
	int32_t cierroDescriptor=0;
	FILE *archivoDisco;

	archivoDisco = fopen(stPPD.szPath, "r" );
	if(archivoDisco==-1)
		perror("open");
	fseek (archivoDisco , 0 , SEEK_END);
	tamanio = ftell (archivoDisco);
	if(tamanio==-1)
		perror("ftell:");
	rewind (archivoDisco);
	cierroDescriptor=fclose(archivoDisco);

	return tamanio;
}

/*============================================================================
Escribo elemento en la lista SSTF()
============================================================================*/
int CargoElementoEnLista(ST_PEDIDOS_INFO info)
{
	ST_PEDIDOS *pAux, *p, *previo;
	ST_CHS chsActual;
	pAux = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	//p = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	//previo = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	//printf("Agrego elemento en la lista\n");
	previo=NULL;
	p=listaPedidos;
	while (p!=NULL)
	{
		previo = p;
		p=p->sgte;
	}

	pAux->socketPedido=info.socketPedido;
	pAux->TipoPedido=info.TipoPedido;
	pAux->prioridad = info.prioridad;
	pAux->chs = LBAtoCHS(info.sector);

	chsActual = LBAtoCHS(stPPD.sectorActual);
	pAux->sector=info.sector;
	//strcpy(pAux->buffer, info.buffer);
	memcpy(pAux->buffer, info.buffer, sizeof(ST_SECTOR));
	pAux->sgte=NULL;

	if (previo==NULL)
	{
		listaPedidos = pAux;
	}else
	{
		previo->sgte = pAux;
		p = previo->sgte;
	}

	//p = pAux;
	//listaPedidos = p;
	//free(pAux);
	//free(p);
	return 0;
}

/*============================================================================
Escribo elemento en la lista N-STEP-SCAN()
============================================================================*/
int CargoElementoEnListaNStep(ST_PEDIDOS_INFO info)
{
	ST_PEDIDOS_NSTEP *p, *pAux, *previo;
	ST_PEDIDOS *pSubLista, *pAuxSubLista, *previoSubLista;
	//p = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));
	pAux = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));
	//previo = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));

	//pSubLista = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	pAuxSubLista = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	//previoSubLista = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));

	int almacenado=0;
//	printf("Empiezo a cargar elementos\n");
	p=listaPedidosNStep;
	previo=NULL;
	while((p!=NULL)&&(almacenado==0))
	{
//		printf("CantElementos: %d\n", p->CantNodosSublistas);
		if(p->CantNodosSublistas < stPPD.cantElementosNStepScan)
		{
			//sectoresPedidosNSTEP();
			//CargoElementoEnListaAlFinal(p->SubLista, info);
			//p->CantNodosSublistas++;
			almacenado=1;
			//printf("CantElementos: %d\n", p->CantNodosSublistas);
		}

		previo = p;
		p=p->sgte;
	}

	pAuxSubLista->socketPedido=info.socketPedido;
	pAuxSubLista->TipoPedido=info.TipoPedido;
	pAuxSubLista->prioridad = info.prioridad;
	pAuxSubLista->sector=info.sector;
	pAuxSubLista->realizado=0;
	//strcpy(pAux->buffer, info.buffer);
	memcpy(pAuxSubLista->buffer, info.buffer, sizeof(ST_SECTOR));
	pAuxSubLista->sgte=NULL;

	if(previo==NULL)
	{
		pAux->CantNodosRealizados=0;
		pAux->CantNodosSublistas=1;
		//CargoElementoEnListaAlFinal(pAux->SubLista, info);
		pAux->sgte = NULL;

		pSubLista=pAux->SubLista;
		previoSubLista=NULL;
		while(pSubLista!=NULL)
		{
			previoSubLista=pSubLista;
			pSubLista=pSubLista->sgte;
		}

		if (previoSubLista==NULL)
		{
			pAux->SubLista = pAuxSubLista;
		}else
		{
			previoSubLista->sgte = pAuxSubLista;
			pSubLista = previoSubLista->sgte;
		}
		listaPedidosNStep = pAux;
		//printf("Paso por aca 1\n");
		//previo->sgte=pAux;
		//p = previo->sgte;
		//p->CantNodosSublistas++;
	}else
	{
		//pAux->CantNodosSublistas = pAux->CantNodosSublistas + 1;
		//CargoElementoEnListaAlFinal(pAux->SubLista, info);
		//pAux->sgte = NULL;
		if(almacenado==1)
		{
			previo->CantNodosSublistas=previo->CantNodosSublistas+1;
			pSubLista=previo->SubLista;
			previoSubLista=NULL;
			while(pSubLista!=NULL)
			{
				previoSubLista=pSubLista;
				pSubLista=pSubLista->sgte;
			}

			if (previoSubLista==NULL)
			{
				previo->SubLista = pAuxSubLista;
			}else
			{
				previoSubLista->sgte = pAuxSubLista;
				pSubLista = previoSubLista->sgte;
			}
			//printf("Paso por aca 2\n");
			//previo->sgte = pAux;
			//p = previo->sgte;
		}else
		{
			pAux->CantNodosSublistas=1;
			pSubLista=pAux->SubLista;
			previoSubLista=NULL;
			while(pSubLista!=NULL)
			{
				previoSubLista=pSubLista;
				pSubLista=pSubLista->sgte;
			}

			if (previoSubLista==NULL)
			{
				pAux->SubLista = pAuxSubLista;
			}else
			{
				previoSubLista->sgte = pAuxSubLista;
				pSubLista = previoSubLista->sgte;
			}
			previo->sgte = pAux;
			p = previo->sgte;
			//printf("Paso por aca 3\n");
		}
	}
	//p->sgte = listaPedidosNStep;
	//listaPedidosNStep = p;
//	free(p);
//	free(pAux);
//	free();
	return 0;
}

int absoluto(int a, int b)
{
	int c;
	if ((c=a-b) < 0)
		c=c*-1;

	return c;
}

/*============================================================================
Traslado pedidos con algoritmo SSTF/SJF()
============================================================================*/
ST_PEDIDOS_INFO trabajoListaPedidosSSTF()
{
	ST_PEDIDOS *pAux;
	ST_PEDIDOS_INFO info;
	int i=0, primero=1, cant=0;
	int sector = 0;
	int encontro=0, encontroElemento=0;
	int tiempoMinimo=0, prioridadMinimo;
//	pAux = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	//sectoresPedidos();
	//ST_CHS actual;
	//actual = LBAtoCHS(stPPD.sectorActual);

	ST_CHS	chsActual;
	//chsActual = LBAtoCHS(25);

	chsActual = LBAtoCHS(stPPD.sectorActual);

	pAux=listaPedidos;
	while (pAux!=NULL)
	{
		if (pAux->chs.cilindro==stPPD.chsActual.cilindro)
		{
			encontroElemento = 1;
			if (primero ==1)
			{
				primero = 0;
				tiempoMinimo = (absoluto(pAux->chs.sector, stPPD.chsActual.sector) * stPPD.tiempoEntreSectores);
				prioridadMinimo = pAux->prioridad;
				sector = pAux->sector;
				info.sector = pAux->sector;
				info.sectorProximo = -1;
				info.socketPedido = pAux->socketPedido;
				info.TipoPedido = pAux->TipoPedido;
				info.prioridad = pAux->prioridad;
				info.subiendo = 0;
				memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));
			}
			else
			{
				encontro = (absoluto(pAux->sector, stPPD.sectorActual) * stPPD.tiempoEntreSectores);
				if(encontro < tiempoMinimo)
				{
					sector = pAux->sector;
					tiempoMinimo = (absoluto(pAux->chs.sector, stPPD.chsActual.sector) * stPPD.tiempoEntreSectores);
					info.sectorProximo = info.sector;
					info.sector = pAux->sector;
					info.socketPedido = pAux->socketPedido;
					info.TipoPedido = pAux->TipoPedido;
					info.prioridad = pAux->prioridad;
					info.subiendo = 0;
					memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));
				}else
				{
					if((encontro = tiempoMinimo) && (pAux->prioridad < prioridadMinimo))
					{
						sector = pAux->sector;
						tiempoMinimo = (absoluto(pAux->chs.sector, stPPD.chsActual.sector) * stPPD.tiempoEntreSectores);
						info.sectorProximo = info.sector;
						info.sector = pAux->sector;
						info.socketPedido = pAux->socketPedido;
						info.TipoPedido = pAux->TipoPedido;
						info.prioridad = pAux->prioridad;
						info.subiendo = 0;
						memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));
					}
				}
			}
		}
		pAux = pAux->sgte;
	}

	if (encontroElemento==0)
		{
		pAux=listaPedidos;
		while (pAux!=NULL)
		{
			if (primero ==1)
			{
				primero = 0;
				tiempoMinimo = (absoluto(pAux->chs.sector, stPPD.chsActual.sector) * stPPD.tiempoEntreSectores) + (absoluto(pAux->chs.cilindro, stPPD.chsActual.cilindro) * stPPD.iTiempoSalto);
				prioridadMinimo = pAux->prioridad;
				sector = pAux->sector;
				info.sector = pAux->sector;
				info.sectorProximo = -1;
				info.socketPedido = pAux->socketPedido;
				info.TipoPedido = pAux->TipoPedido;
				info.prioridad = pAux->prioridad;
				info.subiendo = 0;
				memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));

				//printf("TentreSectores: %d\n", stPPD.tiempoEntreSectores);
				//encontro = absoluto(pAux->sector, stPPD.sectorActual) * stPPD.tiempoEntreSectores;
				//printf("Absoluto: %d\n", encontro);
				//printf("Tiempo minimo: %d\n", tiempoMinimo);
				//printf("Agarro el %d q es primer elemento\n", info.sector);
			}
			else
			{
				//printf("Entro a ver si hay otro mas cercano\n");
				//printf("TentreSectores: %d\n", stPPD.tiempoEntreSectores);
				encontro = (absoluto(pAux->sector, stPPD.sectorActual) * stPPD.tiempoEntreSectores) + (absoluto(pAux->chs.cilindro, stPPD.chsActual.cilindro) * stPPD.iTiempoSalto);
				//printf("Absoluto: %d\n", encontro);
				//printf("Tiempo minimo: %d\n", tiempoMinimo);
				if(encontro < tiempoMinimo)
				{
					sector = pAux->sector;
					tiempoMinimo = (absoluto(pAux->chs.sector, stPPD.chsActual.sector) * stPPD.tiempoEntreSectores) + (absoluto(pAux->chs.cilindro, stPPD.chsActual.cilindro) * stPPD.iTiempoSalto);
					info.sectorProximo = info.sector;
					info.sector = pAux->sector;
					info.socketPedido = pAux->socketPedido;
					info.TipoPedido = pAux->TipoPedido;
					info.prioridad = pAux->prioridad;
					info.subiendo = 0;
					memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));
					//printf("Agarro el %d q es menor el tiempo entre sectores\n", info.sector);
				}else
				{
					if((encontro = tiempoMinimo) && (pAux->prioridad < prioridadMinimo))
					{
						sector = pAux->sector;
						tiempoMinimo = (absoluto(pAux->chs.sector, stPPD.chsActual.sector) * stPPD.tiempoEntreSectores) + (absoluto(pAux->chs.cilindro, stPPD.chsActual.cilindro) * stPPD.iTiempoSalto);
						info.sectorProximo = info.sector;
						info.sector = pAux->sector;
						info.socketPedido = pAux->socketPedido;
						info.TipoPedido = pAux->TipoPedido;
						info.prioridad = pAux->prioridad;
						info.subiendo = 0;
						memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));
						//printf("Agarro el %d q es igual pero tiene mas prioridad\n", info.sector);
					}
				}
			}
			pAux = pAux->sgte;
		}
	}
	//printf("Salgo de la funcion sstf\n");
	//printf("sector: %d\n",info.sector);
	free(pAux);
	//printf("infosector: %d\n", info.sector);
	return info;
}

/*============================================================================
Busco proximo sector en los pedidos SSTF/SJF()
============================================================================*/
ST_PEDIDOS_INFO BuscoProximoSectorSSTF()
{
	ST_PEDIDOS *pAux;
	ST_PEDIDOS_INFO info;
	int primero=1;
	int sector = 0;
	int encontro=0;
	int tiempoMinimo=0, prioridadMinimo;
	pAux = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));

	pAux=listaPedidos;
	//sectoresPedidos();
	info.sector = -1;
	strcpy(info.sectoresPendientes, "");
	while (pAux!=NULL)
	{
		if (primero ==1)
		{
			primero = 0;
			tiempoMinimo = absoluto(pAux->sector, stPPD.sectorActual) * stPPD.tiempoEntreSectores;
			prioridadMinimo = pAux->prioridad;
			sector = pAux->sector;
			info.sector = pAux->sector;
			//printf("entro aca 1 \n");
		}
		else
		{
			encontro = absoluto(pAux->sector, stPPD.sectorActual) * stPPD.tiempoEntreSectores;
			if(encontro < tiempoMinimo)
			{
				sector = pAux->sector;
				tiempoMinimo = absoluto(pAux->sector, stPPD.sectorActual) * stPPD.tiempoEntreSectores;
				info.sector = pAux->sector;
				//printf("entro aca 2 \n");
			}else
			{
				if((encontro = tiempoMinimo) && (pAux->prioridad < prioridadMinimo))
				{
					sector = pAux->sector;
					tiempoMinimo = absoluto(pAux->sector, stPPD.sectorActual) * stPPD.tiempoEntreSectores;
					info.sector = pAux->sector;
					//printf("entro aca 3 \n");
				}
			}
		}
		pAux = pAux->sgte;
	}
	free(pAux);
	//printf("Sector: %d\n", info.sector);
	return info;
}


/*============================================================================
Traslado pedidos de cola principal a colas que se trabajaran SSTF/SJF()
============================================================================*/
ST_PEDIDOS_INFO trabajoListaPedidosNStep(ST_PEDIDOS *lista)
{
	ST_PEDIDOS *pAux;
	//ST_PEDIDOS_NSTEP *p;
	ST_PEDIDOS_INFO info;
	//int i=0, cant=0;
	int sector = -1;
	int encontro=0, primero=1;
	//int tiempoMinimo=0, prioridadMinimo;
	pAux = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	//p = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));

	//ordeno lista de menor a mayor segun SSTF
	//while (lista!=NULL)
	//{
	//printf("concha tuya\n");
	//p = listaPedidosNStep;
	info.sector = -1;
	pAux=lista;
	while (pAux!=NULL)
	{
		info.subiendo = 1;
		if ((pAux->sector >= stPPD.sectorActual)&&(pAux->realizado==0))
		{
			if (primero==1)
			{
				sector = pAux->sector;
				info.sectorProximo = info.sector;
				info.sector = pAux->sector;
				info.socketPedido = pAux->socketPedido;
				info.TipoPedido = pAux->TipoPedido;
				info.prioridad = pAux->prioridad;
				info.subiendo = 1;
				memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));
				//printf("Encuentro el primer elemento %d\n", sector);
				primero=0;
			}
			else
			{
				if ((pAux->sector < info.sector)&&(pAux->sector >= stPPD.sectorActual)&&(pAux->sector < sector))
				{
					//encontro=1;
					sector = pAux->sector;
					info.sectorProximo = info.sector;
					info.sector = pAux->sector;
					info.socketPedido = pAux->socketPedido;
					info.TipoPedido = pAux->TipoPedido;
					info.prioridad = pAux->prioridad;
					info.subiendo = 1;
					memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));
					//printf("Encuentro un elemento mayor %d\n", sector);
					//pAux->realizado=1;
				}
				//printf("Encontrado: %d\n", info.sector);
			}
		}
		pAux = pAux->sgte;
	}

	if (sector<0)
	{
		info.subiendo=0;
		stPPD.sectorActual = stPPD.sectoresTotales - 1;
		//printf("Sector actual: %d\n", stPPD.sectorActual);
		primero=1;
		pAux=lista;
		while ((pAux!=NULL)&&(encontro==0))
		{

			if ((pAux->sector < stPPD.sectorActual)&&(pAux->realizado==0))
			{
				if (primero==1)
				{
					sector = pAux->sector;
					info.sectorProximo = info.sector;
					info.sector = pAux->sector;
					info.socketPedido = pAux->socketPedido;
					info.TipoPedido = pAux->TipoPedido;
					info.prioridad = pAux->prioridad;
					info.subiendo = 0;
					memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));
					primero=0;
				}
				else
				{
					if ((pAux->sector > info.sector)&&(pAux->sector <= stPPD.sectorActual))
					{
						//encontro=1;
						sector = pAux->sector;
						info.sectorProximo = info.sector;
						info.sector = pAux->sector;
						info.socketPedido = pAux->socketPedido;
						info.TipoPedido = pAux->TipoPedido;
						info.prioridad = pAux->prioridad;
						info.subiendo = 0;
						memcpy(info.buffer, pAux->buffer, sizeof(ST_SECTOR));
						//pAux->realizado=1;
					}
					//printf("Encontrado: %d\n", info.sector);
				}
			}
			pAux = pAux->sgte;
		}
	}

	if (info.sector > -1)
	{
		//printf("El sector encontrado es el %d\n", info.sector);
		pAux=lista;
		while ((pAux!=NULL)&&(encontro==0))
		{
			if ((pAux->socketPedido==info.socketPedido) && (pAux->sector == info.sector) && (pAux->TipoPedido == info.TipoPedido))
			{
				//printf("Encuentro y pongo que se realizo\n");
				pAux->realizado = 1;
				encontro=1;
			}else
				pAux = pAux->sgte;
		}
	}

	//free(pAux);
	return info;
}

/*============================================================================
Escribo elemento en la lista()
============================================================================*/
int CargoElementoEnListaAlFinal(ST_PEDIDOS *lista, ST_PEDIDOS_INFO info)
{
	ST_PEDIDOS *p, *q;
	p = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	q = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));

	p->socketPedido=info.socketPedido;
	p->TipoPedido=info.TipoPedido;
	p->sector=info.sector;
	p->sgte = NULL;
	//strcpy(p->buffer, info.buffer);
	memcpy(p->buffer, info.buffer, sizeof(ST_SECTOR));

	q = lista;
	while (q!=NULL)
		q=q->sgte;

	if (q==lista)
		q = p;
	else
		q->sgte = p;

	lista = q;
	free(p);
	free(q);
	return 0;
}

/*============================================================================
Escribo elemento en la lista()
============================================================================*/
int CargoElementoEnListaAlFinalNStep()
{
	ST_PEDIDOS_NSTEP *p, *q;
	int cantidad=0;

	p = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));
	q = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));

	p = listaPedidosNStep;

	q=listaPedidosNStep;
	while (q!=NULL)
	{
		q=q->sgte;
		cantidad++;
	}

	p->IdLista=cantidad+1;
	p->CantNodosRealizados=0;
	p->CantNodosSublistas=0;
	p->SubLista=NULL;

	if (q==listaPedidosNStep)
		q = p;
	else
		q->sgte = p;

	listaPedidosNStep = q;
	free(p);
	free(q);
	return 0;
}

///*============================================================================
//Traslado pedidos de cola principal a colas que se trabajaran N-STEP-SCAN()
//============================================================================*/
//int trabajoListaPedidosNStepScan(ST_PEDIDOS *lista, ST_PEDIDOS *listaNueva, ST_PEDIDOS *listaNueva2)
//{
//	ST_PEDIDOS *pAux;
//	ST_PEDIDOS_INFO info;
//	int i=0, cant=0;
//	pAux = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
//
//	pAux=lista;
//	while  (pAux!=NULL)
//		cant++;
//
//	//Recorro lista y voy colocandolo en 2 listas, en formato FIFO
//	pAux=lista;
//	while (pAux!=NULL)
//	{
//		info.sector = pAux->sector;
//		info.socketPedido = pAux->socketPedido;
//		info.TipoPedido = pAux->TipoPedido;
//		strcpy(info.buffer, pAux->buffer);
//
//		if (i<(cant/2))
//			CargoElementoEnListaAlFinal(listaNueva, info);
//		else
//			CargoElementoEnListaAlFinal(listaNueva2, info);
//
//		i++;
//		pAux=pAux->sgte;
//
//	 }
//	return 0;
//}

/*============================================================================
Elimino elemento en la lista()
============================================================================*/
int EliminoElemento(ST_PEDIDOS_INFO info )
{
	ST_PEDIDOS *p, *q;
	int encontro=0;
	//p = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	//q = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	p = listaPedidos;
	q = NULL;
	//sectoresPedidos();
	//printf("voy a eliminar el sector: %i!\n",info.sector);
	while ((p!=NULL) && (encontro==0))
	{
		if ((p->socketPedido==info.socketPedido) && (p->sector == info.sector) && (p->TipoPedido == info.TipoPedido))
		{
			encontro =1;
			if ( q == NULL)
			{
				if( p->sgte == NULL)
				{
					listaPedidos = NULL;
					return 0;
				}else
				{
					listaPedidos = p->sgte;
					free(p);
					return 0;
				}
			}else
			{
				q->sgte = p->sgte;
				p->sgte = NULL;
				free(p);
				return 0;
			}

		}else
		{
			q=p;
			p=p->sgte;
		}
	}
	return 0;
}

/*============================================================================
Elimino elemento en la lista()
============================================================================*/
int EliminoElementoNStep()
{
	ST_PEDIDOS_NSTEP *p, *q;
	int encontro=0;
	p = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));
	//q = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	q = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));
	//printf("TipoOperacion: %u\n", tipoOperacion);
	p = listaPedidosNStep;
	q = NULL;
	//sectoresPedidos();
	//printf("voy a eliminar el sector: %i!\n",info.sector);
	while (p!=NULL)
	{
		if (p->CantNodosRealizados == p->CantNodosSublistas)
		{
			encontro =1;
			//printf("encontro el nodo a eliminar: %d\n",p->sector);
			if ( q == NULL)
			{
				if( p->sgte == NULL)
				{
					listaPedidosNStep = NULL;
					//printf("Encontre y elimino 2\n");
					//printf("cantidad de nodos 2b: %i\n",cantidadPedidos());
					return 0;
				}else
				{
					listaPedidosNStep = p->sgte;
					free(p);
					return 0;
				}
			}else
			{
				q->sgte = p->sgte;
				p->sgte = NULL;

				//listaPedidos = q;
				free(p);
				//free(q);
				//printf("Encontre y elimino por 1\n");
				//printf("cantidad de nodos 2a: %i\n",cantidadPedidos());
				return 0;
			}

		}else
		{
			//if ( q == NULL)
			q=p;
			//else
			//	q->sgte=p;

			p=p->sgte;
		}
	}
	//free(p);
	//free(q);
	return 0;
}

char* get512BytesBlancos()
{
	char* b="";
	int   i;
	for (i=0;i<512;i++)
		strcat(b, '\0');
	return b;
}

int32_t CHStoLBA(ST_CHS buscado)
{
	//LBA = ( (cylinder * heads_per_cylinder + heads ) * sectors_per_track ) + sector - 1
	return (int32_t)(((buscado.cilindro * stPPD.iCilindro + buscado.cabeza ) * stPPD.iSector ) + buscado.sector - 1);
}

void inicializacion (ST_PEDIDOS *lista)
{
	lista->sgte = NULL;
}

void inicializacionNStep (ST_PEDIDOS_NSTEP *lista)
{
	lista->sgte = NULL;
}

int cantidadPedidos()
{
	int cant=0;
	ST_PEDIDOS *p;
	p = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	p=listaPedidos;
	while (p!=NULL)
	{
		cant++;
		p=p->sgte;
	}
	return cant;
}

int sectoresPedidos() //char *Pedido)
{
	//int *Pedido;
	//char *b=(char *) malloc(sizeof(char)*100);
	ST_PEDIDOS *p;
	//p = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));

	//Pedido = (char *) malloc(sizeof(char)*1000000);
	printf("Pendientes: \n", p->sector);
	p=listaPedidos;
	while(p!=NULL)
	{
		printf(" %d  \n", p->sector);
		//strcat(Pedido, b);

		p=p->sgte;
	}
//	printf("Pedidos Disponibles: %s\n", Pedido);
	return 0;
}

int sectoresPedidosNSTEP()
{
	//int *PedidosDisponibles;
	char *b=(char *) malloc(sizeof(char)*100);
	ST_PEDIDOS *p;
	p = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
	ST_PEDIDOS_NSTEP *pN;
	pN = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));

	//PedidosDisponibles = (char *) malloc(sizeof(char)*1000000);
	pN=listaPedidosNStep;
	while(pN!=NULL)
	{
		//strcpy(Pedido, "");
		if (pN->CantNodosRealizados < pN->CantNodosSublistas)
		{
			printf("\n Pendientes: ");
			p=pN->SubLista;
			while(p!=NULL)
			{
				if (p->realizado==0)
				{
					printf(" %d ", p->sector);
				}
				p=p->sgte;
			}
		}
//		printf("Pedidos Disponibles: %s\n", Pedido);
		pN=pN->sgte;
	}
	return 0;
}

int imprimoTrazo(int32_t sectorActual, int32_t sectorPedido)
{
	ST_CHS	chsActual, chsPedido, chsSiguiente;
	char trazo[250000];
	char t[25];
	int i=0, cantPistas=0, cantSectores=0;
	int tiempo=0;
	int32_t sectorSiguiente;

	chsActual = LBAtoCHS(sectorActual);
	chsPedido = LBAtoCHS(sectorPedido);

	printf("\nPosicion Actual: %d:%d\n", chsActual.cilindro, chsActual.sector);
	printf("Posicion Solicitado: %d:%d\n", chsPedido.cilindro, chsPedido.sector);

	strcpy(trazo, "");
	strcpy(t, "");

	sprintf(t, " %d:%d ", chsActual.cilindro, chsActual.sector );
	strcat(trazo, t);

	if(chsActual.cilindro < chsPedido.cilindro)
	{
		for(i=chsActual.cilindro; i < chsPedido.cilindro; i++)
		{
			sprintf(t, " %d:%d ", i, chsPedido.sector );
			strcat(trazo, t);
			cantPistas++;
		}
		chsActual.cilindro = i;
	}
	else if(chsActual.cilindro > chsPedido.cilindro)
	{
		for(i=chsActual.cilindro; i < chsPedido.cilindro; i--)
		{
			sprintf(t, " %d:%d ", i, chsPedido.sector );
			strcat(trazo, t);
			cantPistas++;
		}
		chsActual.cilindro = i;
	}


	if(chsActual.sector < chsPedido.sector)
	{
		for(i=chsActual.sector; i < chsPedido.sector; i++)
		{
			sprintf(t, " %d:%d ", chsActual.cilindro, i );
			strcat(trazo, t);
			cantSectores++;
		}
		chsActual.sector = i;
		sectorSiguiente = chsPedido.sector+1;
	}
	else if(chsActual.sector > chsPedido.sector)
	{
		for(i=chsActual.sector; i < chsPedido.sector; i--)
		{
			sprintf(t, " %d:%d ", chsActual.cilindro, i );
			strcat(trazo, t);
			cantSectores++;
		}
		chsActual.sector = i;
		sectorSiguiente = chsPedido.sector-1;
	}

	sprintf(t, " %d:%d ", chsPedido.cilindro, chsPedido.sector );
	strcat(trazo, t);

	printf("Sectores recorridos: %s\n", trazo);

	//printf("Cant Sectores: %d \n", cantSectores);
	//printf("T. entre sectores: %d ms \n", stPConsola.tiempoEntreSectores);

	tiempo=(cantSectores*stPPD.tiempoEntreSectores)+(cantPistas*stPPD.iTiempoSalto);
	printf("Tiempo Consumido: %d ms \n", tiempo);

	chsSiguiente = LBAtoCHS(sectorSiguiente);
	printf("Proximo Sector: %d:%d \n", chsSiguiente.cilindro, chsSiguiente.sector);

	return 0;
}

int loguear(int32_t sectorActual, int32_t sectorPedido, int32_t sectorProximo, int subiendo )
{
	ST_CHS	chsActual, chsPedido, chsSiguiente;
	//char trazo[25000];
	//char t[25000];
//	char mensaje[25000];
	//char m[25000];
	int i=0, cantPistas=0, cantSectores=0;
	int tiempo=0, menor=0;
	int tama=0;
	int32_t sectorSiguiente;
	int32_t resultado=0;


	//msg=(char *)malloc(sizeof(char)*250);
	FILE		*pArchLog;

	if(stPPD.iFlag != 1)
		return 0;
	else
	{
		char *mensajeLog, *msg, *m, *m2, *trazo, *t;
		mensajeLog=(char *)malloc(sizeof(char)*250000);
		m=(char *)malloc(sizeof(char)*250000);
		m2=(char *)malloc(sizeof(char)*250000);
		trazo=(char *)malloc(sizeof(char)*250000);
		t=(char *)malloc(sizeof(char)*250000);
		pArchLog = fopen("ppdLog.txt","a");

		//fprintf(pArchLog, "");
		//chsActual = LBAtoCHS(sectorActual);
		//chsPedido = LBAtoCHS(sectorPedido);

		//strcpy(mensaje, "");
		//strcpy(m, "");

		if (sectorPedido<=sectorActual)
			menor =1;

		//printf("\nPosicion Actual: %d:%d\n", chsActual.cilindro, chsActual.sector);
		//sprintf(m,"Cola de Pedidos: [%d]\n", Pedido);
		//fprintf(pArchLog, "%s",m);


		sprintf(m,"Info de solicitud\n");
		fprintf(pArchLog, "%s",m);
//		ST_PEDIDOS *p;
//		if (strcmp(stPPD.cAlgoritmo, "SSTF") == 0)
//		{
//			//ST_PEDIDOS *p;
//			p=listaPedidos;
//			fprintf(pArchLog, "Cola de pedidos: [ ");
//			while(p!=NULL)
//			{
//				printf(" %d  \n", p->sector);
//				//strcat(Pedido, b);
//				tama++;
//				i++;
//
//				if (i == 10)
//				{
//					fprintf(pArchLog, " %s ",m);
//					i=0;
//					sprintf(m, "");
//				}
//
//				p=p->sgte;
//			}
//
//			if (i>0)
//				fprintf(pArchLog, " %s ",m);
//
//			fprintf(pArchLog, "\n tamaño = %d ",tama);
//
//		}else
//		{
//
//			//p = (ST_PEDIDOS *) malloc(sizeof(ST_PEDIDOS));
//			ST_PEDIDOS_NSTEP *pN;
//			//pN = (ST_PEDIDOS_NSTEP *) malloc(sizeof(ST_PEDIDOS_NSTEP));
//
//			//PedidosDisponibles = (char *) malloc(sizeof(char)*1000000);
//			pN=listaPedidosNStep;
//			while(pN!=NULL)
//			{
//				//strcpy(Pedido, "");
//				if (pN->CantNodosRealizados < pN->CantNodosSublistas)
//				{
//					tama = 0;
//					sprintf(m, "");
//					p=pN->SubLista;
//					while(p!=NULL)
//					{
//						if (p->realizado==0)
//						{
//							sprintf(m2, " %d ", p->sector);
//							strcat(trazo, m2);
//
//							tama++;
//						}
//
//						sprintf(m, " %s ", trazo);
//						p=p->sgte;
//					}
//					//sprintf("Posicion Actual: %d\n", sectorActual);
//					if (tama>0)
//					{
//						fprintf(pArchLog, "Cola de pedidos: [ %s ] tamaño = %d \n",m, tama);
//					}
//				}
//		//		printf("Pedidos Disponibles: %s\n", Pedido);
//				pN=pN->sgte;
//			}
//		}
//		sprintf(m, "");
		sprintf(m, "Posicion Actual: %d\n", sectorActual);
		fprintf(pArchLog, "%s",m);
		//strcat(mensaje, m);
		sprintf(m,"Posicion Solicitado: %d\n", sectorPedido);
		fprintf(pArchLog, "%s",m);
		//strcat(mensaje, m);

		strcpy(trazo, "");
		strcpy(t, "");

		//sprintf(t, " %d:%d ", chsActual.cilindro, chsActual.sector );
		//strcat(trazo, t);

		/*if(chsActual.cilindro < chsPedido.cilindro)
		{
			for(i=chsActual.cilindro; i < chsPedido.cilindro; i++)
			{
				sprintf(t, " %d:%d ", i, chsPedido.sector );
				strcat(trazo, t);
				cantPistas++;
			}
			chsActual.cilindro = i;
		}
		else if(chsActual.cilindro > chsPedido.cilindro)
		{
			for(i=chsActual.cilindro; i < chsPedido.cilindro; i--)
			{
				sprintf(t, " %d:%d ", i, chsPedido.sector );
				strcat(trazo, t);
				cantPistas++;
			}
			chsActual.cilindro = i;
		}*/


		if(sectorActual < sectorPedido)
		{
//			for(i=sectorActual; i < sectorPedido; i++)
//			{
//				sprintf(t, " %d ", i );
//				strcat(trazo, t);
//				cantSectores++;
//			}
//			sectorActual = i;
//			sectorSiguiente = sectorPedido+1;
			resultado = (sectorPedido - sectorActual) / 2;
			resultado = resultado + sectorActual;
			if ((resultado > sectorActual)&&(resultado < sectorPedido))
			{
				sprintf(t, " %d .. %d .. %d ", sectorActual, resultado, sectorPedido);
				strcat(trazo, t);
				//printf("actual: %d .. %d .. %d ", sectorActual, resultado, sectorPedido);
			}else if(resultado > sectorActual)
			{
				sprintf(t, " %d .. %d ", sectorActual, resultado);
				strcat(trazo, t);
//				printf("actual: %d .. %d ", sectorActual, resultado);
			}else if(resultado < sectorPedido)
			{
				sprintf(t, " %d .. %d ", resultado, sectorPedido);
				strcat(trazo, t);
//				printf("actual: %d .. %d ", resultado, sectorPedido);
			}
//			while (resultado < sectorPedido)
//			{
//				resultado = resultado + sectorActual;
//				sprintf(t, ".. %d ", resultado);
//				strcat(trazo, t);
//				printf("resultado: %d ", resultado);
//			}
//			if (resultado != sectorPedido )
//			{
//				sprintf(t, ".. %d ", sectorPedido );
//				strcat(trazo, t);
//				printf("pedido: %d ", sectorPedido);
//			}

		}
		else if(sectorActual > sectorPedido)
		{
//			for(i=sectorActual; i > sectorPedido; i--)
//			{
//				sprintf(t, " %d ", i );
//				strcat(trazo, t);
//				cantSectores++;
//			}
//			sectorActual = i;
//			sectorSiguiente = sectorPedido-1;
//			printf("Por aca\n");
			resultado = (sectorActual - sectorPedido) / 2;
			resultado = sectorActual - resultado;
			if ((resultado < sectorActual)&&(resultado > sectorPedido))
			{
				sprintf(t, " %d .. %d .. %d ", sectorActual, resultado, sectorPedido);
				strcat(trazo, t);
//				printf("actual: %d .. %d .. %d ", sectorActual, resultado, sectorPedido);
			}else if(resultado < sectorActual)
			{
				sprintf(t, " %d .. %d ", resultado, sectorActual);
				strcat(trazo, t);
//				printf("actual: %d .. %d ", resultado, sectorActual);
			}else if(resultado > sectorPedido)
			{
				sprintf(t, " %d .. %d ", sectorPedido, resultado);
				strcat(trazo, t);
//				printf("actual: %d .. %d ", sectorPedido, resultado);
			}
			//sprintf(t, " %d .. %d .. %d ", sectorPedido, resultado, sectorActual );
			//strcat(trazo, t);
		}

		//sprintf(t, " %d ", sectorPedido );
		//strcat(trazo, t);

		sprintf(m, "Sectores recorridos: %s\n", trazo);
		fprintf(pArchLog, "%s",m);
		//strcat(mensaje, m);

		tiempo=(cantSectores*stPPD.tiempoEntreSectores)+(cantPistas*stPPD.iTiempoSalto);
		sprintf(m, "Tiempo Consumido: %d ms \n", tiempo);
		fprintf(pArchLog, "%s",m);
		//strcat(mensaje, m);

		chsSiguiente = LBAtoCHS(sectorSiguiente);

		//if (sectorProximo<0)
		//	sprintf(m, "Proximo Sector: 0 \n");
		//else if (sectorSiguiente>stPPD.sectoresTotales)
		//	sprintf(m, "Proximo Sector: %d \n", stPPD.sectoresTotales);
		//else
		if (sectorProximo > -1)
			sprintf(m, "Proximo Sector: %d \n", sectorProximo);
		else
			sprintf(m, "Proximo Sector: \n");

		fprintf(pArchLog, "%s",m);
		//strcat(mensaje, m);

		//log( "ppdLog.txt", "PFD", "INFO", mensaje);
		fclose(pArchLog);

		free(mensajeLog);
		free(m);
		free(trazo);
		free(t);
	}
	return 0;
}

void posicionoCabezal(int32_t sectorPedido)
{
	ST_CHS	chsActual, chsPedido, chsNuevo;
	int32_t	sectorNuevo;
	chsActual = LBAtoCHS(stPPD.sectorActual);
	chsPedido = LBAtoCHS(sectorPedido);

	if (chsActual.sector > chsPedido.sector)
		sectorNuevo = sectorPedido - 1;
	else
		sectorNuevo = sectorPedido + 1;

	if (sectorNuevo < 0)
		sectorNuevo = 0;

//	if (stPPD.sectorActual < sectorPedido)
//		sectorNuevo = sectorPedido + 1;
//	else
//		sectorNuevo = sectorPedido - 1;

//	printf("Sector Actual: %d\n", stPPD.sectorActual);
//	printf("Sector Pedido: %d\n", sectorPedido);
//	printf("Sector Nuevo: %d\n", sectorNuevo);
	chsNuevo = LBAtoCHS(sectorNuevo);
//	printf("Nuevo  s: %d c: %d \n", chsNuevo.sector, chsNuevo.cilindro);

	if (chsNuevo.cilindro != chsPedido.cilindro)
	{
		if (chsPedido.sector == 0)
		{
			//printf("por aca\n");
			chsNuevo.sector = stPPD.iSector;
			stPPD.sectorActual= sectorNuevo + stPPD.iSector;
			//stPPD.chsActual = LBAtoCHS(stPPD.sectorActual);
		}else if (chsPedido.sector == stPPD.iSector - 1)
		{
			chsNuevo.sector = 0;
			stPPD.sectorActual= 0;
			//stPPD.chsActual = LBAtoCHS(stPPD.sectorActual);
			//printf("es menor o igual\n");
			//chsNuevo.sector = stPPD.iSector;
		}
//		chsNuevo.cilindro = chsPedido.cilindro;
//		chsNuevo.cabeza = 1;
//		printf("Actual s: %d c: %d \n", chsActual.sector, chsActual.cilindro);
//		printf("Pedido s: %d c: %d \n", chsPedido.sector, chsPedido.cilindro);
//		printf("Nuevo  s: %d c: %d h: %d \n", chsNuevo.sector, chsNuevo.cilindro, chsNuevo.cabeza);
//		stPPD.sectorActual = CHStoLBA(chsNuevo);
//		printf("Actual: %d\n", stPPD.sectorActual);
	}else
	{
		stPPD.sectorActual= sectorNuevo;
		//stPPD.chsActual = LBAtoCHS(stPPD.sectorActual);
	}
//	printf("Sector Actual: %d\n", stPPD.sectorActual);
}

#endif
